type ArrType = any[]
/**
 * 去重函数
 */
const noRepeat = (arr: ArrType) => {
  return arr.reduce((brr, item) => {
    brr.indexOf(item) === -1 && brr.push(item)
    return brr
  }, [])
}

// let it = noRepeat([1, 2, 2, 2, 2, 23, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6])

// console.log(it, 'it')

/**
 * 回文判断函数
 *
 * reverStr('ab') // false
 * reverStr('cac') // true
 * reverStr('abba') // true
 *
 */

/**
 * 路由表过滤
 * 将以下路由表：过滤成一个tree结构
 */
import { ArrItem } from './types/tree.d'

// 转换前的结构
const data: ArrItem[] = [
  { id: 1, name: '用户管理', pid: 0, path: 'user' },
  { id: 2, name: '菜单申请', pid: 1, path: 'setting' },
  { id: 3, name: '信息申请', pid: 1, path: 'msg' },
  { id: 4, name: '模块记录', pid: 2, path: 'model' },
  { id: 5, name: '系统设置', pid: 0, path: 'system' },
  { id: 6, name: '权限管理', pid: 5, path: 'auth' },
  { id: 7, name: '用户角色', pid: 6, path: 'role' },
  { id: 8, name: '菜单设置', pid: 6, path: '菜单设置' },
]

// 转换后的结构
const filterResult = [
  {
    id: 1,
    pid: 0,
    name: '用户管理',
    children: [
      { id: 3, name: '信息申请', pid: 1, path: 'msg' },
      {
        id: 2,
        name: '菜单申请',
        pid: 1,
        path: 'setting',
        children: [{ id: 4, name: '模块记录', pid: 2, path: 'model' }],
      },
    ],
  },
  {
    id: 5,
    name: '系统设置',
    pid: 0,
    path: 'system',
    children: [
      {
        id: 6,
        name: '权限管理',
        pid: 5,
        path: 'auth',
        children: [
          { id: 8, name: '菜单设置', pid: 6, path: '菜单设置' },
          { id: 7, name: '用户角色', pid: 6, path: 'role' },
        ],
      },
    ],
  },
]

function filterData(data: ArrItem[]) {
  const parents = data.filter((item) => item.pid === 0)
  const children = data.filter((v) => v.pid !== 0)
  dataToTree(parents, children)
  return parents
}

function dataToTree(parents: ArrItem[], children: ArrItem[]) {
  // 1. 父 parents
  // 2. 子 children
  // 3. 遍历的过程中，就是要把子pid跟父id相等的放置在父的children下
  // 4. 判断父是否有children
  // 5. 如果有children 直接push
  // 6. 如果没有children 创建children=[],并且把子符合内容放在数组中
  // 7. 如果children内部还有后续元素，继续以上6步 借助递归
  // 注意：要把每一个处理后的子的元素，删除掉，然后重新放置在递归函数中，
  // （这个元素我已经处理过了，不再处理了，删除掉就可以不处理了）
  // 但是删除采用splice会影响 数组，所以，在这个地方，会有一个拷贝
  // 只针对拷贝的数据，进行删除，然后，将处理好的children,递归进一步循环
  parents.forEach((element) => {
    children.forEach((item, i) => {
      if (element.id === item.pid) {
        let _c = JSON.parse(JSON.stringify(children))
        _c.splice(i, 1)
        dataToTree([item], _c)

        // 判断
        if (element.children) {
          element.children.push(item)
        } else {
          element.children = [item]
        }
      }
    })
  })
}

let it = filterData(data)
console.log(it, 'it')
